// Copyright 2008 Google Inc.
// All Rights Reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: vladl@google.com (Vlad Losev)

// Type and function utilities for implementing parameterized tests.

#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_

#include <ctype.h>

#include <iterator>
#include <set>
#include <utility>
#include <vector>

// scripts/fuse_gtest.py depends on gtest's own header being #included
// *unconditionally*.  Therefore these #includes cannot be moved
// inside #if GTEST_HAS_PARAM_TEST.
#include "gtest/internal/gtest-internal.h"
#include "gtest/internal/gtest-linked_ptr.h"
#include "gtest/internal/gtest-port.h"
#include "gtest/gtest-printers.h"

#if GTEST_HAS_PARAM_TEST

namespace testing
{

// Input to a parameterized test name generator, describing a test parameter.
// Consists of the parameter value and the integer parameter index.
template<class ParamType>
struct TestParamInfo
{
  TestParamInfo(const ParamType &a_param, size_t an_index)
    : param(a_param)
    , index(an_index)
  {
  }
  ParamType param;
  size_t index;
};

// A builtin parameterized test name generator which returns the result of
// testing::PrintToString.
struct PrintToStringParamName
{
  template<class ParamType>
  std::string operator()(const TestParamInfo<ParamType> &info) const
  {
    return PrintToString(info.param);
  }
};

namespace internal
{

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Outputs a message explaining invalid registration of different
// fixture class for the same test case. This may happen when
// TEST_P macro is used to define two tests with the same name
// but in different namespaces.
GTEST_API_ void ReportInvalidTestCaseType(const char *test_case_name,
                                          CodeLocation code_location);

template<typename>
class ParamGeneratorInterface;
template<typename>
class ParamGenerator;

// Interface for iterating over elements provided by an implementation
// of ParamGeneratorInterface<T>.
template<typename T>
class ParamIteratorInterface
{
public:
  virtual ~ParamIteratorInterface() {}
  // A pointer to the base generator instance.
  // Used only for the purposes of iterator comparison
  // to make sure that two iterators belong to the same generator.
  virtual const ParamGeneratorInterface<T> *BaseGenerator() const = 0;
  // Advances iterator to point to the next element
  // provided by the generator. The caller is responsible
  // for not calling Advance() on an iterator equal to
  // BaseGenerator()->End().
  virtual void Advance() = 0;
  // Clones the iterator object. Used for implementing copy semantics
  // of ParamIterator<T>.
  virtual ParamIteratorInterface *Clone() const = 0;
  // Dereferences the current iterator and provides (read-only) access
  // to the pointed value. It is the caller's responsibility not to call
  // Current() on an iterator equal to BaseGenerator()->End().
  // Used for implementing ParamGenerator<T>::operator*().
  virtual const T *Current() const = 0;
  // Determines whether the given iterator and other point to the same
  // element in the sequence generated by the generator.
  // Used for implementing ParamGenerator<T>::operator==().
  virtual bool Equals(const ParamIteratorInterface &other) const = 0;
};

// Class iterating over elements provided by an implementation of
// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
// and implements the const forward iterator concept.
template<typename T>
class ParamIterator
{
public:
  typedef T value_type;
  typedef const T &reference;
  typedef ptrdiff_t difference_type;

  // ParamIterator assumes ownership of the impl_ pointer.
  ParamIterator(const ParamIterator &other)
    : impl_(other.impl_->Clone())
  {
  }
  ParamIterator &operator=(const ParamIterator &other)
  {
    if (this != &other)
      impl_.reset(other.impl_->Clone());
    return *this;
  }

  const T &operator*() const { return *impl_->Current(); }
  const T *operator->() const { return impl_->Current(); }
  // Prefix version of operator++.
  ParamIterator &operator++()
  {
    impl_->Advance();
    return *this;
  }
  // Postfix version of operator++.
  ParamIterator operator++(int /*unused*/)
  {
    ParamIteratorInterface<T> *clone = impl_->Clone();
    impl_->Advance();
    return ParamIterator(clone);
  }
  bool operator==(const ParamIterator &other) const
  {
    return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);
  }
  bool operator!=(const ParamIterator &other) const
  {
    return !(*this == other);
  }

private:
  friend class ParamGenerator<T>;
  explicit ParamIterator(ParamIteratorInterface<T> *impl)
    : impl_(impl)
  {
  }
  scoped_ptr<ParamIteratorInterface<T>> impl_;
};

// ParamGeneratorInterface<T> is the binary interface to access generators
// defined in other translation units.
template<typename T>
class ParamGeneratorInterface
{
public:
  typedef T ParamType;

  virtual ~ParamGeneratorInterface() {}

  // Generator interface definition
  virtual ParamIteratorInterface<T> *Begin() const = 0;
  virtual ParamIteratorInterface<T> *End() const = 0;
};

// Wraps ParamGeneratorInterface<T> and provides general generator syntax
// compatible with the STL Container concept.
// This class implements copy initialization semantics and the contained
// ParamGeneratorInterface<T> instance is shared among all copies
// of the original object. This is possible because that instance is immutable.
template<typename T>
class ParamGenerator
{
public:
  typedef ParamIterator<T> iterator;

  explicit ParamGenerator(ParamGeneratorInterface<T> *impl)
    : impl_(impl)
  {
  }
  ParamGenerator(const ParamGenerator &other)
    : impl_(other.impl_)
  {
  }

  ParamGenerator &operator=(const ParamGenerator &other)
  {
    impl_ = other.impl_;
    return *this;
  }

  iterator begin() const { return iterator(impl_->Begin()); }
  iterator end() const { return iterator(impl_->End()); }

private:
  linked_ptr<const ParamGeneratorInterface<T>> impl_;
};

// Generates values from a range of two comparable values. Can be used to
// generate sequences of user-defined types that implement operator+() and
// operator<().
// This class is used in the Range() function.
template<typename T, typename IncrementT>
class RangeGenerator : public ParamGeneratorInterface<T>
{
public:
  RangeGenerator(T begin, T end, IncrementT step)
    : begin_(begin)
    , end_(end)
    , step_(step)
    , end_index_(CalculateEndIndex(begin, end, step))
  {
  }
  virtual ~RangeGenerator() {}

  virtual ParamIteratorInterface<T> *Begin() const
  {
    return new Iterator(this, begin_, 0, step_);
  }
  virtual ParamIteratorInterface<T> *End() const
  {
    return new Iterator(this, end_, end_index_, step_);
  }

private:
  class Iterator : public ParamIteratorInterface<T>
  {
  public:
    Iterator(const ParamGeneratorInterface<T> *base, T value, int index,
             IncrementT step)
      : base_(base)
      , value_(value)
      , index_(index)
      , step_(step)
    {
    }
    virtual ~Iterator() {}

    virtual const ParamGeneratorInterface<T> *BaseGenerator() const
    {
      return base_;
    }
    virtual void Advance()
    {
      value_ = static_cast<T>(value_ + step_);
      index_++;
    }
    virtual ParamIteratorInterface<T> *Clone() const
    {
      return new Iterator(*this);
    }
    virtual const T *Current() const { return &value_; }
    virtual bool Equals(const ParamIteratorInterface<T> &other) const
    {
      // Having the same base generator guarantees that the other
      // iterator is of the same type and we can downcast.
      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
          << "The program attempted to compare iterators "
          << "from different generators." << std::endl;
      const int other_index
          = CheckedDowncastToActualType<const Iterator>(&other)->index_;
      return index_ == other_index;
    }

  private:
    Iterator(const Iterator &other)
      : ParamIteratorInterface<T>()
      , base_(other.base_)
      , value_(other.value_)
      , index_(other.index_)
      , step_(other.step_)
    {
    }

    // No implementation - assignment is unsupported.
    void operator=(const Iterator &other);

    const ParamGeneratorInterface<T> *const base_;
    T value_;
    int index_;
    const IncrementT step_;
  }; // class RangeGenerator::Iterator

  static int CalculateEndIndex(const T &begin, const T &end,
                               const IncrementT &step)
  {
    int end_index = 0;
    for (T i = begin; i < end; i = static_cast<T>(i + step))
      end_index++;
    return end_index;
  }

  // No implementation - assignment is unsupported.
  void operator=(const RangeGenerator &other);

  const T begin_;
  const T end_;
  const IncrementT step_;
  // The index for the end() iterator. All the elements in the generated
  // sequence are indexed (0-based) to aid iterator comparison.
  const int end_index_;
}; // class RangeGenerator

// Generates values from a pair of STL-style iterators. Used in the
// ValuesIn() function. The elements are copied from the source range
// since the source can be located on the stack, and the generator
// is likely to persist beyond that stack frame.
template<typename T>
class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T>
{
public:
  template<typename ForwardIterator>
  ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
    : container_(begin, end)
  {
  }
  virtual ~ValuesInIteratorRangeGenerator() {}

  virtual ParamIteratorInterface<T> *Begin() const
  {
    return new Iterator(this, container_.begin());
  }
  virtual ParamIteratorInterface<T> *End() const
  {
    return new Iterator(this, container_.end());
  }

private:
  typedef typename ::std::vector<T> ContainerType;

  class Iterator : public ParamIteratorInterface<T>
  {
  public:
    Iterator(const ParamGeneratorInterface<T> *base,
             typename ContainerType::const_iterator iterator)
      : base_(base)
      , iterator_(iterator)
    {
    }
    virtual ~Iterator() {}

    virtual const ParamGeneratorInterface<T> *BaseGenerator() const
    {
      return base_;
    }
    virtual void Advance()
    {
      ++iterator_;
      value_.reset();
    }
    virtual ParamIteratorInterface<T> *Clone() const
    {
      return new Iterator(*this);
    }
    // We need to use cached value referenced by iterator_ because *iterator_
    // can return a temporary object (and of type other then T), so just
    // having "return &*iterator_;" doesn't work.
    // value_ is updated here and not in Advance() because Advance()
    // can advance iterator_ beyond the end of the range, and we cannot
    // detect that fact. The client code, on the other hand, is
    // responsible for not calling Current() on an out-of-range iterator.
    virtual const T *Current() const
    {
      if (value_.get() == NULL)
        value_.reset(new T(*iterator_));
      return value_.get();
    }
    virtual bool Equals(const ParamIteratorInterface<T> &other) const
    {
      // Having the same base generator guarantees that the other
      // iterator is of the same type and we can downcast.
      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
          << "The program attempted to compare iterators "
          << "from different generators." << std::endl;
      return iterator_
             == CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
    }

  private:
    Iterator(const Iterator &other)
      // The explicit constructor call suppresses a false warning
      // emitted by gcc when supplied with the -Wextra option.
      : ParamIteratorInterface<T>()
      , base_(other.base_)
      , iterator_(other.iterator_)
    {
    }

    const ParamGeneratorInterface<T> *const base_;
    typename ContainerType::const_iterator iterator_;
    // A cached value of *iterator_. We keep it here to allow access by
    // pointer in the wrapping iterator's operator->().
    // value_ needs to be mutable to be accessed in Current().
    // Use of scoped_ptr helps manage cached value's lifetime,
    // which is bound by the lifespan of the iterator itself.
    mutable scoped_ptr<const T> value_;
  }; // class ValuesInIteratorRangeGenerator::Iterator

  // No implementation - assignment is unsupported.
  void operator=(const ValuesInIteratorRangeGenerator &other);

  const ContainerType container_;
}; // class ValuesInIteratorRangeGenerator

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Default parameterized test name generator, returns a string containing the
// integer test parameter index.
template<class ParamType>
std::string DefaultParamName(const TestParamInfo<ParamType> &info)
{
  Message name_stream;
  name_stream << info.index;
  return name_stream.GetString();
}

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Parameterized test name overload helpers, which help the
// INSTANTIATE_TEST_CASE_P macro choose between the default parameterized
// test name generator and user param name generator.
template<class ParamType, class ParamNameGenFunctor>
ParamNameGenFunctor GetParamNameGen(ParamNameGenFunctor func)
{
  return func;
}

template<class ParamType>
struct ParamNameGenFunc
{
  typedef std::string Type(const TestParamInfo<ParamType> &);
};

template<class ParamType>
typename ParamNameGenFunc<ParamType>::Type *GetParamNameGen()
{
  return DefaultParamName;
}

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Stores a parameter value and later creates tests parameterized with that
// value.
template<class TestClass>
class ParameterizedTestFactory : public TestFactoryBase
{
public:
  typedef typename TestClass::ParamType ParamType;
  explicit ParameterizedTestFactory(ParamType parameter)
    : parameter_(parameter)
  {
  }
  virtual Test *CreateTest()
  {
    TestClass::SetParam(&parameter_);
    return new TestClass();
  }

private:
  const ParamType parameter_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
};

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// TestMetaFactoryBase is a base class for meta-factories that create
// test factories for passing into MakeAndRegisterTestInfo function.
template<class ParamType>
class TestMetaFactoryBase
{
public:
  virtual ~TestMetaFactoryBase() {}

  virtual TestFactoryBase *CreateTestFactory(ParamType parameter) = 0;
};

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// TestMetaFactory creates test factories for passing into
// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
// ownership of test factory pointer, same factory object cannot be passed
// into that method twice. But ParameterizedTestCaseInfo is going to call
// it for each Test/Parameter value combination. Thus it needs meta factory
// creator class.
template<class TestCase>
class TestMetaFactory : public TestMetaFactoryBase<typename TestCase::ParamType>
{
public:
  typedef typename TestCase::ParamType ParamType;

  TestMetaFactory() {}

  virtual TestFactoryBase *CreateTestFactory(ParamType parameter)
  {
    return new ParameterizedTestFactory<TestCase>(parameter);
  }

private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
};

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// ParameterizedTestCaseInfoBase is a generic interface
// to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase
// accumulates test information provided by TEST_P macro invocations
// and generators provided by INSTANTIATE_TEST_CASE_P macro invocations
// and uses that information to register all resulting test instances
// in RegisterTests method. The ParameterizeTestCaseRegistry class holds
// a collection of pointers to the ParameterizedTestCaseInfo objects
// and calls RegisterTests() on each of them when asked.
class ParameterizedTestCaseInfoBase
{
public:
  virtual ~ParameterizedTestCaseInfoBase() {}

  // Base part of test case name for display purposes.
  virtual const string &GetTestCaseName() const = 0;
  // Test case id to verify identity.
  virtual TypeId GetTestCaseTypeId() const = 0;
  // UnitTest class invokes this method to register tests in this
  // test case right before running them in RUN_ALL_TESTS macro.
  // This method should not be called more then once on any single
  // instance of a ParameterizedTestCaseInfoBase derived class.
  virtual void RegisterTests() = 0;

protected:
  ParameterizedTestCaseInfoBase() {}

private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase);
};

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// ParameterizedTestCaseInfo accumulates tests obtained from TEST_P
// macro invocations for a particular test case and generators
// obtained from INSTANTIATE_TEST_CASE_P macro invocations for that
// test case. It registers tests with all values generated by all
// generators when asked.
template<class TestCase>
class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase
{
public:
  // ParamType and GeneratorCreationFunc are private types but are required
  // for declarations of public methods AddTestPattern() and
  // AddTestCaseInstantiation().
  typedef typename TestCase::ParamType ParamType;
  // A function that returns an instance of appropriate generator type.
  typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
  typedef typename ParamNameGenFunc<ParamType>::Type ParamNameGeneratorFunc;

  explicit ParameterizedTestCaseInfo(const char *name,
                                     CodeLocation code_location)
    : test_case_name_(name)
    , code_location_(code_location)
  {
  }

  // Test case base name for display purposes.
  virtual const string &GetTestCaseName() const { return test_case_name_; }
  // Test case id to verify identity.
  virtual TypeId GetTestCaseTypeId() const { return GetTypeId<TestCase>(); }
  // TEST_P macro uses AddTestPattern() to record information
  // about a single test in a LocalTestInfo structure.
  // test_case_name is the base name of the test case (without invocation
  // prefix). test_base_name is the name of an individual test without
  // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
  // test case base name and DoBar is test base name.
  void AddTestPattern(const char *test_case_name, const char *test_base_name,
                      TestMetaFactoryBase<ParamType> *meta_factory)
  {
    tests_.push_back(linked_ptr<TestInfo>(
        new TestInfo(test_case_name, test_base_name, meta_factory)));
  }
  // INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information
  // about a generator.
  int AddTestCaseInstantiation(const string &instantiation_name,
                               GeneratorCreationFunc *func,
                               ParamNameGeneratorFunc *name_func,
                               const char *file, int line)
  {
    instantiations_.push_back(
        InstantiationInfo(instantiation_name, func, name_func, file, line));
    return 0; // Return value used only to run this method in namespace scope.
  }
  // UnitTest class invokes this method to register tests in this test case
  // test cases right before running tests in RUN_ALL_TESTS macro.
  // This method should not be called more then once on any single
  // instance of a ParameterizedTestCaseInfoBase derived class.
  // UnitTest has a guard to prevent from calling this method more then once.
  virtual void RegisterTests()
  {
    for (typename TestInfoContainer::iterator test_it = tests_.begin();
         test_it != tests_.end(); ++test_it)
    {
      linked_ptr<TestInfo> test_info = *test_it;
      for (typename InstantiationContainer::iterator gen_it
           = instantiations_.begin();
           gen_it != instantiations_.end(); ++gen_it)
      {
        const string &instantiation_name = gen_it->name;
        ParamGenerator<ParamType> generator((*gen_it->generator)());
        ParamNameGeneratorFunc *name_func = gen_it->name_func;
        const char *file = gen_it->file;
        int line = gen_it->line;

        string test_case_name;
        if (!instantiation_name.empty())
          test_case_name = instantiation_name + "/";
        test_case_name += test_info->test_case_base_name;

        size_t i = 0;
        std::set<std::string> test_param_names;
        for (typename ParamGenerator<ParamType>::iterator param_it
             = generator.begin();
             param_it != generator.end(); ++param_it, ++i)
        {
          Message test_name_stream;

          std::string param_name
              = name_func(TestParamInfo<ParamType>(*param_it, i));

          GTEST_CHECK_(IsValidParamName(param_name))
              << "Parameterized test name '" << param_name
              << "' is invalid, in " << file << " line " << line << std::endl;

          GTEST_CHECK_(test_param_names.count(param_name) == 0)
              << "Duplicate parameterized test name '" << param_name << "', in "
              << file << " line " << line << std::endl;

          test_param_names.insert(param_name);

          test_name_stream << test_info->test_base_name << "/" << param_name;
          MakeAndRegisterTestInfo(
              test_case_name.c_str(), test_name_stream.GetString().c_str(),
              NULL, // No type parameter.
              PrintToString(*param_it).c_str(), code_location_,
              GetTestCaseTypeId(), TestCase::SetUpTestCase,
              TestCase::TearDownTestCase,
              test_info->test_meta_factory->CreateTestFactory(*param_it));
        } // for param_it
      } // for gen_it
    } // for test_it
  } // RegisterTests

private:
  // LocalTestInfo structure keeps information about a single test registered
  // with TEST_P macro.
  struct TestInfo
  {
    TestInfo(const char *a_test_case_base_name, const char *a_test_base_name,
             TestMetaFactoryBase<ParamType> *a_test_meta_factory)
      : test_case_base_name(a_test_case_base_name)
      , test_base_name(a_test_base_name)
      , test_meta_factory(a_test_meta_factory)
    {
    }

    const string test_case_base_name;
    const string test_base_name;
    const scoped_ptr<TestMetaFactoryBase<ParamType>> test_meta_factory;
  };
  typedef ::std::vector<linked_ptr<TestInfo>> TestInfoContainer;
  // Records data received from INSTANTIATE_TEST_CASE_P macros:
  //  <Instantiation name, Sequence generator creation function,
  //     Name generator function, Source file, Source line>
  struct InstantiationInfo
  {
    InstantiationInfo(const std::string &name_in,
                      GeneratorCreationFunc *generator_in,
                      ParamNameGeneratorFunc *name_func_in, const char *file_in,
                      int line_in)
      : name(name_in)
      , generator(generator_in)
      , name_func(name_func_in)
      , file(file_in)
      , line(line_in)
    {
    }

    std::string name;
    GeneratorCreationFunc *generator;
    ParamNameGeneratorFunc *name_func;
    const char *file;
    int line;
  };
  typedef ::std::vector<InstantiationInfo> InstantiationContainer;

  static bool IsValidParamName(const std::string &name)
  {
    // Check for empty string
    if (name.empty())
      return false;

    // Check for invalid characters
    for (std::string::size_type index = 0; index < name.size(); ++index)
    {
      if (!isalnum(name[index]) && name[index] != '_')
        return false;
    }

    return true;
  }

  const string test_case_name_;
  CodeLocation code_location_;
  TestInfoContainer tests_;
  InstantiationContainer instantiations_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo);
}; // class ParameterizedTestCaseInfo

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase
// classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P
// macros use it to locate their corresponding ParameterizedTestCaseInfo
// descriptors.
class ParameterizedTestCaseRegistry
{
public:
  ParameterizedTestCaseRegistry() {}
  ~ParameterizedTestCaseRegistry()
  {
    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
         it != test_case_infos_.end(); ++it)
    {
      delete *it;
    }
  }

  // Looks up or creates and returns a structure containing information about
  // tests and instantiations of a particular test case.
  template<class TestCase>
  ParameterizedTestCaseInfo<TestCase> *
  GetTestCasePatternHolder(const char *test_case_name,
                           CodeLocation code_location)
  {
    ParameterizedTestCaseInfo<TestCase> *typed_test_info = NULL;
    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
         it != test_case_infos_.end(); ++it)
    {
      if ((*it)->GetTestCaseName() == test_case_name)
      {
        if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>())
        {
          // Complain about incorrect usage of Google Test facilities
          // and terminate the program since we cannot guaranty correct
          // test case setup and tear-down in this case.
          ReportInvalidTestCaseType(test_case_name, code_location);
          posix::Abort();
        }
        else
        {
          // At this point we are sure that the object we found is of the same
          // type we are looking for, so we downcast it to that type
          // without further checks.
          typed_test_info = CheckedDowncastToActualType<
              ParameterizedTestCaseInfo<TestCase>>(*it);
        }
        break;
      }
    }
    if (typed_test_info == NULL)
    {
      typed_test_info = new ParameterizedTestCaseInfo<TestCase>(test_case_name,
                                                                code_location);
      test_case_infos_.push_back(typed_test_info);
    }
    return typed_test_info;
  }
  void RegisterTests()
  {
    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
         it != test_case_infos_.end(); ++it)
    {
      (*it)->RegisterTests();
    }
  }

private:
  typedef ::std::vector<ParameterizedTestCaseInfoBase *> TestCaseInfoContainer;

  TestCaseInfoContainer test_case_infos_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry);
};

} // namespace internal
} // namespace testing

#endif //  GTEST_HAS_PARAM_TEST

#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
